home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / eiffel / smalleif.97 / se.t / SmallEiffel / bin_c / compile_to_c20.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-05-02  |  29.1 KB  |  1,319 lines
  1. /* ANSI C code generated by SmallEiffel. */
  2. /*
  3. -- SmallEiffel  -- Release (- 0.97)    --      FRANCE
  4. -- Copyright (C), 1994 - Dominique COLNET and Suzanne COLLIN 
  5. -- University Henri Poincare' - Nancy 1 - email colnet@loria.fr 
  6. -- CRIN (Centre de Recherche en Informatique de Nancy)
  7. -- FRANCE 
  8. */
  9. #include "compile_to_c.h"
  10. void rT275clear(T275 *C){
  11. C->_upper=((C)->_lower)-(1);
  12. }
  13. void rT275clear_all(T275 *C){
  14. T0 * _value=NULL;
  15. rT275set_all_with(C,_value);
  16. }
  17. int rT275count(T275 *C){
  18. int R=0;
  19. R=(((C)->_upper)-((C)->_lower))+(1);
  20. return R;
  21. }
  22. void rT275set_all_with(T275 *C,T0 * a1){
  23. int _i=0;
  24. _i=(C)->_upper;
  25. while (!((_i)<((C)->_lower))) {
  26. rT275put(C,a1,_i);
  27. _i=(_i)-(1);
  28. }
  29. }
  30. void rT275resize(T275 *C,int a1,int a2){
  31. int _up=0;
  32. int _i=0;
  33. T0* _other=NULL;
  34. {T275 *n=((T275*)new(275));
  35. rT275make(n,a1,a2);
  36. _other=(T0 *)n;}
  37. _i=rT2max((C)->_lower,((T275*)_other)->_lower);
  38. _up=rT2min((C)->_upper,((T275*)_other)->_upper);
  39. while (!((_i)>(_up))) {
  40. rT275put((T275*)_other,rT275item(C,_i),_i);
  41. _i=(_i)+(1);
  42. }
  43. /*IF*/{/*AT*/free(C->_storage);
  44. }
  45. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  46. }
  47. int rT275fast_index_of(T275 *C,T0 * a1){
  48. int R=0;
  49. R=(C)->_lower;
  50. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT275item(C,R))))) {
  51. R=(R)+(1);
  52. }
  53. return R;
  54. }
  55. int rT275fast_has(T275 *C,T0 * a1){
  56. int R=0;
  57. R=(rT275fast_index_of(C,a1))!=(((C)->_upper)+(1));
  58. return R;
  59. }
  60. int rT275empty(T275 *C){
  61. int R=0;
  62. R=(rT275count(C))==(0);
  63. return R;
  64. }
  65. T0 * rT275item(T275 *C,int a1){
  66. T0 * R=NULL;
  67. R=(C->_storage)[a1-(C->_lower)];
  68. return R;
  69. }
  70. void rT275add_last(T275 *C,T0 * a1){
  71. /*IF*/if (((C)->_capacity)<((rT275count(C))+(1))) {
  72. C->_capacity=((C)->_capacity)+(16);
  73. /*IF*/if (((C)->_capacity)==(16)) {
  74. C->_storage=malloc(16*sizeof(*(C->_storage)));
  75. }
  76. else {
  77. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  78. }
  79. /*FI*/}
  80. /*FI*/C->_upper=((C)->_upper)+(1);
  81. rT275put(C,a1,(C)->_upper);
  82. }
  83. void rT275put(T275 *C,T0 * a1,int a2){
  84. (C->_storage)[a2-(C->_lower)]=a1;
  85. }
  86. void rT275copy(T275 *C,T0* a1){
  87. int _i=0;
  88. C->_upper=((C)->_lower)-(1);
  89. /*IF*/if (((C)->_capacity)==(0)) {
  90. rT275make(C,((T275*)a1)->_lower,((T275*)a1)->_upper);
  91. }
  92. else {
  93. rT275resize(C,((T275*)a1)->_lower,((T275*)a1)->_upper);
  94. }
  95. /*FI*/_i=(C)->_lower;
  96. while (!((_i)>((C)->_upper))) {
  97. rT275put(C,rT275item((T275*)a1,_i),_i);
  98. _i=(_i)+(1);
  99. }
  100. }
  101. void rT275make(T275 *C,int a1,int a2){
  102. /*IF*/{/*AT*/free(C->_storage);
  103. }
  104. /*FI*/C->_lower=a1;
  105. C->_upper=a2;
  106. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  107. C->_storage=NULL;
  108. /*IF*/if (((C)->_capacity)>(0)) {
  109. C->_capacity=((C)->_capacity)+(16);
  110. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  111. rT275clear_all(C);
  112. }
  113. /*FI*/}
  114. void rT274clear_all(T274 *C){
  115. T0 * _value=NULL;
  116. rT274set_all_with(C,_value);
  117. }
  118. int rT274count(T274 *C){
  119. int R=0;
  120. R=(((C)->_upper)-((C)->_lower))+(1);
  121. return R;
  122. }
  123. void rT274set_all_with(T274 *C,T0 * a1){
  124. int _i=0;
  125. _i=(C)->_upper;
  126. while (!((_i)<((C)->_lower))) {
  127. rT274put(C,a1,_i);
  128. _i=(_i)-(1);
  129. }
  130. }
  131. int rT274fast_has(T274 *C,T0 * a1){
  132. int R=0;
  133. R=(rT274fast_index_of(C,a1))!=(((C)->_upper)+(1));
  134. return R;
  135. }
  136. int rT274fast_index_of(T274 *C,T0 * a1){
  137. int R=0;
  138. R=(C)->_lower;
  139. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT274item(C,R))))) {
  140. R=(R)+(1);
  141. }
  142. return R;
  143. }
  144. void rT274resize(T274 *C,int a1,int a2){
  145. int _up=0;
  146. int _i=0;
  147. T0* _other=NULL;
  148. {T274 *n=((T274*)new(274));
  149. rT274make(n,a1,a2);
  150. _other=(T0 *)n;}
  151. _i=rT2max((C)->_lower,((T274*)_other)->_lower);
  152. _up=rT2min((C)->_upper,((T274*)_other)->_upper);
  153. while (!((_i)>(_up))) {
  154. rT274put((T274*)_other,rT274item(C,_i),_i);
  155. _i=(_i)+(1);
  156. }
  157. /*IF*/{/*AT*/free(C->_storage);
  158. }
  159. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  160. }
  161. void rT274force(T274 *C,T0 * a1,int a2){
  162. /*IF*/if (((C)->_upper)<(a2)) {
  163. rT274resize(C,(C)->_lower,a2);
  164. }
  165.  else if ((a2)<((C)->_lower)) {
  166. rT274resize(C,a2,(C)->_upper);
  167. }
  168. /*FI*/rT274put(C,a1,a2);
  169. }
  170. T0 * rT274item(T274 *C,int a1){
  171. T0 * R=NULL;
  172. R=(C->_storage)[a1-(C->_lower)];
  173. return R;
  174. }
  175. void rT274add_last(T274 *C,T0 * a1){
  176. /*IF*/if (((C)->_capacity)<((rT274count(C))+(1))) {
  177. C->_capacity=((C)->_capacity)+(16);
  178. /*IF*/if (((C)->_capacity)==(16)) {
  179. C->_storage=malloc(16*sizeof(*(C->_storage)));
  180. }
  181. else {
  182. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  183. }
  184. /*FI*/}
  185. /*FI*/C->_upper=((C)->_upper)+(1);
  186. rT274put(C,a1,(C)->_upper);
  187. }
  188. void rT274put(T274 *C,T0 * a1,int a2){
  189. (C->_storage)[a2-(C->_lower)]=a1;
  190. }
  191. void rT274copy(T274 *C,T0* a1){
  192. int _i=0;
  193. C->_upper=((C)->_lower)-(1);
  194. /*IF*/if (((C)->_capacity)==(0)) {
  195. rT274make(C,((T274*)a1)->_lower,((T274*)a1)->_upper);
  196. }
  197. else {
  198. rT274resize(C,((T274*)a1)->_lower,((T274*)a1)->_upper);
  199. }
  200. /*FI*/_i=(C)->_lower;
  201. while (!((_i)>((C)->_upper))) {
  202. rT274put(C,rT274item((T274*)a1,_i),_i);
  203. _i=(_i)+(1);
  204. }
  205. }
  206. void rT274make(T274 *C,int a1,int a2){
  207. /*IF*/{/*AT*/free(C->_storage);
  208. }
  209. /*FI*/C->_lower=a1;
  210. C->_upper=a2;
  211. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  212. C->_storage=NULL;
  213. /*IF*/if (((C)->_capacity)>(0)) {
  214. C->_capacity=((C)->_capacity)+(16);
  215. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  216. rT274clear_all(C);
  217. }
  218. /*FI*/}
  219. void rT272clear_all(T272 *C){
  220. T0 * _value=NULL;
  221. rT272set_all_with(C,_value);
  222. }
  223. void rT272set_all_with(T272 *C,T0 * a1){
  224. int _i=0;
  225. _i=(C)->_upper;
  226. while (!((_i)<((C)->_lower))) {
  227. rT272put(C,a1,_i);
  228. _i=(_i)-(1);
  229. }
  230. }
  231. void rT272resize(T272 *C,int a1,int a2){
  232. int _up=0;
  233. int _i=0;
  234. T0* _other=NULL;
  235. {T272 *n=((T272*)new(272));
  236. rT272make(n,a1,a2);
  237. _other=(T0 *)n;}
  238. _i=rT2max((C)->_lower,((T272*)_other)->_lower);
  239. _up=rT2min((C)->_upper,((T272*)_other)->_upper);
  240. while (!((_i)>(_up))) {
  241. rT272put((T272*)_other,rT272item(C,_i),_i);
  242. _i=(_i)+(1);
  243. }
  244. /*IF*/{/*AT*/free(C->_storage);
  245. }
  246. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  247. }
  248. T0 * rT272item(T272 *C,int a1){
  249. T0 * R=NULL;
  250. R=(C->_storage)[a1-(C->_lower)];
  251. return R;
  252. }
  253. void rT272put(T272 *C,T0 * a1,int a2){
  254. (C->_storage)[a2-(C->_lower)]=a1;
  255. }
  256. void rT272copy(T272 *C,T0* a1){
  257. int _i=0;
  258. C->_upper=((C)->_lower)-(1);
  259. /*IF*/if (((C)->_capacity)==(0)) {
  260. rT272make(C,((T272*)a1)->_lower,((T272*)a1)->_upper);
  261. }
  262. else {
  263. rT272resize(C,((T272*)a1)->_lower,((T272*)a1)->_upper);
  264. }
  265. /*FI*/_i=(C)->_lower;
  266. while (!((_i)>((C)->_upper))) {
  267. rT272put(C,rT272item((T272*)a1,_i),_i);
  268. _i=(_i)+(1);
  269. }
  270. }
  271. void rT272make(T272 *C,int a1,int a2){
  272. /*IF*/{/*AT*/free(C->_storage);
  273. }
  274. /*FI*/C->_lower=a1;
  275. C->_upper=a2;
  276. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  277. C->_storage=NULL;
  278. /*IF*/if (((C)->_capacity)>(0)) {
  279. C->_capacity=((C)->_capacity)+(16);
  280. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  281. rT272clear_all(C);
  282. }
  283. /*FI*/}
  284. void rT271clear_all(T271 *C){
  285. T0 * _value=NULL;
  286. rT271set_all_with(C,_value);
  287. }
  288. int rT271count(T271 *C){
  289. int R=0;
  290. R=(((C)->_upper)-((C)->_lower))+(1);
  291. return R;
  292. }
  293. void rT271set_all_with(T271 *C,T0 * a1){
  294. int _i=0;
  295. _i=(C)->_upper;
  296. while (!((_i)<((C)->_lower))) {
  297. rT271put(C,a1,_i);
  298. _i=(_i)-(1);
  299. }
  300. }
  301. void rT271resize(T271 *C,int a1,int a2){
  302. int _up=0;
  303. int _i=0;
  304. T0* _other=NULL;
  305. {T271 *n=((T271*)new(271));
  306. rT271make(n,a1,a2);
  307. _other=(T0 *)n;}
  308. _i=rT2max((C)->_lower,((T271*)_other)->_lower);
  309. _up=rT2min((C)->_upper,((T271*)_other)->_upper);
  310. while (!((_i)>(_up))) {
  311. rT271put((T271*)_other,rT271item(C,_i),_i);
  312. _i=(_i)+(1);
  313. }
  314. /*IF*/{/*AT*/free(C->_storage);
  315. }
  316. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  317. }
  318. T0 * rT271item(T271 *C,int a1){
  319. T0 * R=NULL;
  320. R=(C->_storage)[a1-(C->_lower)];
  321. return R;
  322. }
  323. void rT271add_last(T271 *C,T0 * a1){
  324. /*IF*/if (((C)->_capacity)<((rT271count(C))+(1))) {
  325. C->_capacity=((C)->_capacity)+(16);
  326. /*IF*/if (((C)->_capacity)==(16)) {
  327. C->_storage=malloc(16*sizeof(*(C->_storage)));
  328. }
  329. else {
  330. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  331. }
  332. /*FI*/}
  333. /*FI*/C->_upper=((C)->_upper)+(1);
  334. rT271put(C,a1,(C)->_upper);
  335. }
  336. void rT271put(T271 *C,T0 * a1,int a2){
  337. (C->_storage)[a2-(C->_lower)]=a1;
  338. }
  339. void rT271copy(T271 *C,T0* a1){
  340. int _i=0;
  341. C->_upper=((C)->_lower)-(1);
  342. /*IF*/if (((C)->_capacity)==(0)) {
  343. rT271make(C,((T271*)a1)->_lower,((T271*)a1)->_upper);
  344. }
  345. else {
  346. rT271resize(C,((T271*)a1)->_lower,((T271*)a1)->_upper);
  347. }
  348. /*FI*/_i=(C)->_lower;
  349. while (!((_i)>((C)->_upper))) {
  350. rT271put(C,rT271item((T271*)a1,_i),_i);
  351. _i=(_i)+(1);
  352. }
  353. }
  354. void rT271make(T271 *C,int a1,int a2){
  355. /*IF*/{/*AT*/free(C->_storage);
  356. }
  357. /*FI*/C->_lower=a1;
  358. C->_upper=a2;
  359. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  360. C->_storage=NULL;
  361. /*IF*/if (((C)->_capacity)>(0)) {
  362. C->_capacity=((C)->_capacity)+(16);
  363. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  364. rT271clear_all(C);
  365. }
  366. /*FI*/}
  367. void rT270clear_all(T270 *C){
  368. T0* _value=NULL;
  369. rT270set_all_with(C,_value);
  370. }
  371. void rT270set_all_with(T270 *C,T0* a1){
  372. int _i=0;
  373. _i=(C)->_upper;
  374. while (!((_i)<((C)->_lower))) {
  375. rT270put(C,a1,_i);
  376. _i=(_i)-(1);
  377. }
  378. }
  379. void rT270resize(T270 *C,int a1,int a2){
  380. int _up=0;
  381. int _i=0;
  382. T0* _other=NULL;
  383. {T270 *n=((T270*)new(270));
  384. rT270make(n,a1,a2);
  385. _other=(T0 *)n;}
  386. _i=rT2max((C)->_lower,((T270*)_other)->_lower);
  387. _up=rT2min((C)->_upper,((T270*)_other)->_upper);
  388. while (!((_i)>(_up))) {
  389. rT270put((T270*)_other,rT270item(C,_i),_i);
  390. _i=(_i)+(1);
  391. }
  392. /*IF*/{/*AT*/free(C->_storage);
  393. }
  394. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  395. }
  396. T0* rT270item(T270 *C,int a1){
  397. T0* R=NULL;
  398. R=(C->_storage)[a1-(C->_lower)];
  399. return R;
  400. }
  401. void rT270force(T270 *C,T0* a1,int a2){
  402. /*IF*/if (((C)->_upper)<(a2)) {
  403. rT270resize(C,(C)->_lower,a2);
  404. }
  405.  else if ((a2)<((C)->_lower)) {
  406. rT270resize(C,a2,(C)->_upper);
  407. }
  408. /*FI*/rT270put(C,a1,a2);
  409. }
  410. int rT270valid_index(T270 *C,int a1){
  411. int R=0;
  412. R=(((C)->_lower)<=(a1))&&((a1)<=((C)->_upper));
  413. return R;
  414. }
  415. void rT270put(T270 *C,T0* a1,int a2){
  416. (C->_storage)[a2-(C->_lower)]=a1;
  417. }
  418. void rT270copy(T270 *C,T0* a1){
  419. int _i=0;
  420. C->_upper=((C)->_lower)-(1);
  421. /*IF*/if (((C)->_capacity)==(0)) {
  422. rT270make(C,((T270*)a1)->_lower,((T270*)a1)->_upper);
  423. }
  424. else {
  425. rT270resize(C,((T270*)a1)->_lower,((T270*)a1)->_upper);
  426. }
  427. /*FI*/_i=(C)->_lower;
  428. while (!((_i)>((C)->_upper))) {
  429. rT270put(C,rT270item((T270*)a1,_i),_i);
  430. _i=(_i)+(1);
  431. }
  432. }
  433. void rT270make(T270 *C,int a1,int a2){
  434. /*IF*/{/*AT*/free(C->_storage);
  435. }
  436. /*FI*/C->_lower=a1;
  437. C->_upper=a2;
  438. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  439. C->_storage=NULL;
  440. /*IF*/if (((C)->_capacity)>(0)) {
  441. C->_capacity=((C)->_capacity)+(16);
  442. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  443. rT270clear_all(C);
  444. }
  445. /*FI*/}
  446. void rT268clear(T268 *C){
  447. C->_upper=((C)->_lower)-(1);
  448. }
  449. void rT268clear_all(T268 *C){
  450. T0 * _value=NULL;
  451. rT268set_all_with(C,_value);
  452. }
  453. T0 * rT268first(T268 *C){
  454. T0 * R=NULL;
  455. R=rT268item(C,(C)->_lower);
  456. return R;
  457. }
  458. int rT268count(T268 *C){
  459. int R=0;
  460. R=(((C)->_upper)-((C)->_lower))+(1);
  461. return R;
  462. }
  463. void rT268set_all_with(T268 *C,T0 * a1){
  464. int _i=0;
  465. _i=(C)->_upper;
  466. while (!((_i)<((C)->_lower))) {
  467. rT268put(C,a1,_i);
  468. _i=(_i)-(1);
  469. }
  470. }
  471. void rT268resize(T268 *C,int a1,int a2){
  472. int _up=0;
  473. int _i=0;
  474. T0* _other=NULL;
  475. {T268 *n=((T268*)new(268));
  476. rT268make(n,a1,a2);
  477. _other=(T0 *)n;}
  478. _i=rT2max((C)->_lower,((T268*)_other)->_lower);
  479. _up=rT2min((C)->_upper,((T268*)_other)->_upper);
  480. while (!((_i)>(_up))) {
  481. rT268put((T268*)_other,rT268item(C,_i),_i);
  482. _i=(_i)+(1);
  483. }
  484. /*IF*/{/*AT*/free(C->_storage);
  485. }
  486. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  487. }
  488. int rT268fast_index_of(T268 *C,T0 * a1){
  489. int R=0;
  490. R=(C)->_lower;
  491. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT268item(C,R))))) {
  492. R=(R)+(1);
  493. }
  494. return R;
  495. }
  496. int rT268fast_has(T268 *C,T0 * a1){
  497. int R=0;
  498. R=(rT268fast_index_of(C,a1))!=(((C)->_upper)+(1));
  499. return R;
  500. }
  501. int rT268empty(T268 *C){
  502. int R=0;
  503. R=(rT268count(C))==(0);
  504. return R;
  505. }
  506. T0 * rT268item(T268 *C,int a1){
  507. T0 * R=NULL;
  508. R=(C->_storage)[a1-(C->_lower)];
  509. return R;
  510. }
  511. void rT268add_last(T268 *C,T0 * a1){
  512. /*IF*/if (((C)->_capacity)<((rT268count(C))+(1))) {
  513. C->_capacity=((C)->_capacity)+(16);
  514. /*IF*/if (((C)->_capacity)==(16)) {
  515. C->_storage=malloc(16*sizeof(*(C->_storage)));
  516. }
  517. else {
  518. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  519. }
  520. /*FI*/}
  521. /*FI*/C->_upper=((C)->_upper)+(1);
  522. rT268put(C,a1,(C)->_upper);
  523. }
  524. void rT268put(T268 *C,T0 * a1,int a2){
  525. (C->_storage)[a2-(C->_lower)]=a1;
  526. }
  527. void rT268copy(T268 *C,T0* a1){
  528. int _i=0;
  529. C->_upper=((C)->_lower)-(1);
  530. /*IF*/if (((C)->_capacity)==(0)) {
  531. rT268make(C,((T268*)a1)->_lower,((T268*)a1)->_upper);
  532. }
  533. else {
  534. rT268resize(C,((T268*)a1)->_lower,((T268*)a1)->_upper);
  535. }
  536. /*FI*/_i=(C)->_lower;
  537. while (!((_i)>((C)->_upper))) {
  538. rT268put(C,rT268item((T268*)a1,_i),_i);
  539. _i=(_i)+(1);
  540. }
  541. }
  542. void rT268make(T268 *C,int a1,int a2){
  543. /*IF*/{/*AT*/free(C->_storage);
  544. }
  545. /*FI*/C->_lower=a1;
  546. C->_upper=a2;
  547. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  548. C->_storage=NULL;
  549. /*IF*/if (((C)->_capacity)>(0)) {
  550. C->_capacity=((C)->_capacity)+(16);
  551. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  552. rT268clear_all(C);
  553. }
  554. /*FI*/}
  555. void rT265clear_all(T265 *C){
  556. T0 * _value=NULL;
  557. rT265set_all_with(C,_value);
  558. }
  559. int rT265count(T265 *C){
  560. int R=0;
  561. R=(((C)->_upper)-((C)->_lower))+(1);
  562. return R;
  563. }
  564. void rT265set_all_with(T265 *C,T0 * a1){
  565. int _i=0;
  566. _i=(C)->_upper;
  567. while (!((_i)<((C)->_lower))) {
  568. rT265put(C,a1,_i);
  569. _i=(_i)-(1);
  570. }
  571. }
  572. int rT265fast_index_of(T265 *C,T0 * a1){
  573. int R=0;
  574. R=(C)->_lower;
  575. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT265item(C,R))))) {
  576. R=(R)+(1);
  577. }
  578. return R;
  579. }
  580. int rT265fast_has(T265 *C,T0 * a1){
  581. int R=0;
  582. R=(rT265fast_index_of(C,a1))!=(((C)->_upper)+(1));
  583. return R;
  584. }
  585. void rT265resize(T265 *C,int a1,int a2){
  586. int _up=0;
  587. int _i=0;
  588. T0* _other=NULL;
  589. {T265 *n=((T265*)new(265));
  590. rT265make(n,a1,a2);
  591. _other=(T0 *)n;}
  592. _i=rT2max((C)->_lower,XrT265lower(_other));
  593. _up=rT2min((C)->_upper,XrT265upper(_other));
  594. while (!((_i)>(_up))) {
  595. XrT265put(_other,rT265item(C,_i),_i);
  596. _i=(_i)+(1);
  597. }
  598. /*IF*/{/*AT*/free(C->_storage);
  599. }
  600. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  601. }
  602. T0 * rT265item(T265 *C,int a1){
  603. T0 * R=NULL;
  604. R=(C->_storage)[a1-(C->_lower)];
  605. return R;
  606. }
  607. void rT265force(T265 *C,T0 * a1,int a2){
  608. /*IF*/if (((C)->_upper)<(a2)) {
  609. rT265resize(C,(C)->_lower,a2);
  610. }
  611.  else if ((a2)<((C)->_lower)) {
  612. rT265resize(C,a2,(C)->_upper);
  613. }
  614. /*FI*/rT265put(C,a1,a2);
  615. }
  616. void rT265add_last(T265 *C,T0 * a1){
  617. /*IF*/if (((C)->_capacity)<((rT265count(C))+(1))) {
  618. C->_capacity=((C)->_capacity)+(16);
  619. /*IF*/if (((C)->_capacity)==(16)) {
  620. C->_storage=malloc(16*sizeof(*(C->_storage)));
  621. }
  622. else {
  623. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  624. }
  625. /*FI*/}
  626. /*FI*/C->_upper=((C)->_upper)+(1);
  627. rT265put(C,a1,(C)->_upper);
  628. }
  629. void rT265put(T265 *C,T0 * a1,int a2){
  630. (C->_storage)[a2-(C->_lower)]=a1;
  631. }
  632. void rT265copy(T265 *C,T0* a1){
  633. int _i=0;
  634. C->_upper=((C)->_lower)-(1);
  635. /*IF*/if (((C)->_capacity)==(0)) {
  636. rT265make(C,XrT265lower(a1),XrT265upper(a1));
  637. }
  638. else {
  639. rT265resize(C,XrT265lower(a1),XrT265upper(a1));
  640. }
  641. /*FI*/_i=(C)->_lower;
  642. while (!((_i)>((C)->_upper))) {
  643. rT265put(C,XrT265item(a1,_i),_i);
  644. _i=(_i)+(1);
  645. }
  646. }
  647. void rT265make(T265 *C,int a1,int a2){
  648. /*IF*/{/*AT*/free(C->_storage);
  649. }
  650. /*FI*/C->_lower=a1;
  651. C->_upper=a2;
  652. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  653. C->_storage=NULL;
  654. /*IF*/if (((C)->_capacity)>(0)) {
  655. C->_capacity=((C)->_capacity)+(16);
  656. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  657. rT265clear_all(C);
  658. }
  659. /*FI*/}
  660. void rT263clear_all(T263 *C){
  661. T0 * _value=NULL;
  662. rT263set_all_with(C,_value);
  663. }
  664. T0 * rT263first(T263 *C){
  665. T0 * R=NULL;
  666. R=rT263item(C,(C)->_lower);
  667. return R;
  668. }
  669. int rT263count(T263 *C){
  670. int R=0;
  671. R=(((C)->_upper)-((C)->_lower))+(1);
  672. return R;
  673. }
  674. void rT263set_all_with(T263 *C,T0 * a1){
  675. int _i=0;
  676. _i=(C)->_upper;
  677. while (!((_i)<((C)->_lower))) {
  678. rT263put(C,a1,_i);
  679. _i=(_i)-(1);
  680. }
  681. }
  682. int rT263fast_index_of(T263 *C,T0 * a1){
  683. int R=0;
  684. R=(C)->_lower;
  685. while (!(((R)>((C)->_upper))||(((T0 *)a1)==((T0 *)rT263item(C,R))))) {
  686. R=(R)+(1);
  687. }
  688. return R;
  689. }
  690. int rT263fast_has(T263 *C,T0 * a1){
  691. int R=0;
  692. R=(rT263fast_index_of(C,a1))!=(((C)->_upper)+(1));
  693. return R;
  694. }
  695. void rT263resize(T263 *C,int a1,int a2){
  696. int _up=0;
  697. int _i=0;
  698. T0* _other=NULL;
  699. {T263 *n=((T263*)new(263));
  700. rT263make(n,a1,a2);
  701. _other=(T0 *)n;}
  702. _i=rT2max((C)->_lower,((T263*)_other)->_lower);
  703. _up=rT2min((C)->_upper,((T263*)_other)->_upper);
  704. while (!((_i)>(_up))) {
  705. rT263put((T263*)_other,rT263item(C,_i),_i);
  706. _i=(_i)+(1);
  707. }
  708. /*IF*/{/*AT*/free(C->_storage);
  709. }
  710. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  711. }
  712. int rT263empty(T263 *C){
  713. int R=0;
  714. R=(rT263count(C))==(0);
  715. return R;
  716. }
  717. T0 * rT263item(T263 *C,int a1){
  718. T0 * R=NULL;
  719. R=(C->_storage)[a1-(C->_lower)];
  720. return R;
  721. }
  722. void rT263add_last(T263 *C,T0 * a1){
  723. /*IF*/if (((C)->_capacity)<((rT263count(C))+(1))) {
  724. C->_capacity=((C)->_capacity)+(16);
  725. /*IF*/if (((C)->_capacity)==(16)) {
  726. C->_storage=malloc(16*sizeof(*(C->_storage)));
  727. }
  728. else {
  729. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  730. }
  731. /*FI*/}
  732. /*FI*/C->_upper=((C)->_upper)+(1);
  733. rT263put(C,a1,(C)->_upper);
  734. }
  735. void rT263put(T263 *C,T0 * a1,int a2){
  736. (C->_storage)[a2-(C->_lower)]=a1;
  737. }
  738. void rT263copy(T263 *C,T0* a1){
  739. int _i=0;
  740. C->_upper=((C)->_lower)-(1);
  741. /*IF*/if (((C)->_capacity)==(0)) {
  742. rT263make(C,((T263*)a1)->_lower,((T263*)a1)->_upper);
  743. }
  744. else {
  745. rT263resize(C,((T263*)a1)->_lower,((T263*)a1)->_upper);
  746. }
  747. /*FI*/_i=(C)->_lower;
  748. while (!((_i)>((C)->_upper))) {
  749. rT263put(C,rT263item((T263*)a1,_i),_i);
  750. _i=(_i)+(1);
  751. }
  752. }
  753. void rT263swap(T263 *C,int a1,int a2){
  754. T0 * _tmp=NULL;
  755. _tmp=rT263item(C,a1);
  756. rT263put(C,rT263item(C,a2),a1);
  757. rT263put(C,_tmp,a2);
  758. }
  759. void rT263make(T263 *C,int a1,int a2){
  760. /*IF*/{/*AT*/free(C->_storage);
  761. }
  762. /*FI*/C->_lower=a1;
  763. C->_upper=a2;
  764. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  765. C->_storage=NULL;
  766. /*IF*/if (((C)->_capacity)>(0)) {
  767. C->_capacity=((C)->_capacity)+(16);
  768. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  769. rT263clear_all(C);
  770. }
  771. /*FI*/}
  772. void rT258clear_all(T258 *C){
  773. T0 * _value=NULL;
  774. rT258set_all_with(C,_value);
  775. }
  776. int rT258count(T258 *C){
  777. int R=0;
  778. R=(((C)->_upper)-((C)->_lower))+(1);
  779. return R;
  780. }
  781. void rT258set_all_with(T258 *C,T0 * a1){
  782. int _i=0;
  783. _i=(C)->_upper;
  784. while (!((_i)<((C)->_lower))) {
  785. rT258put(C,a1,_i);
  786. _i=(_i)-(1);
  787. }
  788. }
  789. void rT258resize(T258 *C,int a1,int a2){
  790. int _up=0;
  791. int _i=0;
  792. T0* _other=NULL;
  793. {T258 *n=((T258*)new(258));
  794. rT258make(n,a1,a2);
  795. _other=(T0 *)n;}
  796. _i=rT2max((C)->_lower,((T258*)_other)->_lower);
  797. _up=rT2min((C)->_upper,((T258*)_other)->_upper);
  798. while (!((_i)>(_up))) {
  799. rT258put((T258*)_other,rT258item(C,_i),_i);
  800. _i=(_i)+(1);
  801. }
  802. /*IF*/{/*AT*/free(C->_storage);
  803. }
  804. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  805. }
  806. T0 * rT258item(T258 *C,int a1){
  807. T0 * R=NULL;
  808. R=(C->_storage)[a1-(C->_lower)];
  809. return R;
  810. }
  811. void rT258add_last(T258 *C,T0 * a1){
  812. /*IF*/if (((C)->_capacity)<((rT258count(C))+(1))) {
  813. C->_capacity=((C)->_capacity)+(16);
  814. /*IF*/if (((C)->_capacity)==(16)) {
  815. C->_storage=malloc(16*sizeof(*(C->_storage)));
  816. }
  817. else {
  818. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  819. }
  820. /*FI*/}
  821. /*FI*/C->_upper=((C)->_upper)+(1);
  822. rT258put(C,a1,(C)->_upper);
  823. }
  824. void rT258put(T258 *C,T0 * a1,int a2){
  825. (C->_storage)[a2-(C->_lower)]=a1;
  826. }
  827. void rT258copy(T258 *C,T0* a1){
  828. int _i=0;
  829. C->_upper=((C)->_lower)-(1);
  830. /*IF*/if (((C)->_capacity)==(0)) {
  831. rT258make(C,((T258*)a1)->_lower,((T258*)a1)->_upper);
  832. }
  833. else {
  834. rT258resize(C,((T258*)a1)->_lower,((T258*)a1)->_upper);
  835. }
  836. /*FI*/_i=(C)->_lower;
  837. while (!((_i)>((C)->_upper))) {
  838. rT258put(C,rT258item((T258*)a1,_i),_i);
  839. _i=(_i)+(1);
  840. }
  841. }
  842. void rT258make(T258 *C,int a1,int a2){
  843. /*IF*/{/*AT*/free(C->_storage);
  844. }
  845. /*FI*/C->_lower=a1;
  846. C->_upper=a2;
  847. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  848. C->_storage=NULL;
  849. /*IF*/if (((C)->_capacity)>(0)) {
  850. C->_capacity=((C)->_capacity)+(16);
  851. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  852. rT258clear_all(C);
  853. }
  854. /*FI*/}
  855. void rT234clear_all(T234 *C){
  856. T0 * _value=NULL;
  857. rT234set_all_with(C,_value);
  858. }
  859. int rT234count(T234 *C){
  860. int R=0;
  861. R=(((C)->_upper)-((C)->_lower))+(1);
  862. return R;
  863. }
  864. void rT234set_all_with(T234 *C,T0 * a1){
  865. int _i=0;
  866. _i=(C)->_upper;
  867. while (!((_i)<((C)->_lower))) {
  868. rT234put(C,a1,_i);
  869. _i=(_i)-(1);
  870. }
  871. }
  872. void rT234resize(T234 *C,int a1,int a2){
  873. int _up=0;
  874. int _i=0;
  875. T0* _other=NULL;
  876. {T234 *n=((T234*)new(234));
  877. rT234make(n,a1,a2);
  878. _other=(T0 *)n;}
  879. _i=rT2max((C)->_lower,((T234*)_other)->_lower);
  880. _up=rT2min((C)->_upper,((T234*)_other)->_upper);
  881. while (!((_i)>(_up))) {
  882. rT234put((T234*)_other,rT234item(C,_i),_i);
  883. _i=(_i)+(1);
  884. }
  885. /*IF*/{/*AT*/free(C->_storage);
  886. }
  887. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  888. }
  889. T0 * rT234item(T234 *C,int a1){
  890. T0 * R=NULL;
  891. R=(C->_storage)[a1-(C->_lower)];
  892. return R;
  893. }
  894. void rT234add_last(T234 *C,T0 * a1){
  895. /*IF*/if (((C)->_capacity)<((rT234count(C))+(1))) {
  896. C->_capacity=((C)->_capacity)+(16);
  897. /*IF*/if (((C)->_capacity)==(16)) {
  898. C->_storage=malloc(16*sizeof(*(C->_storage)));
  899. }
  900. else {
  901. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  902. }
  903. /*FI*/}
  904. /*FI*/C->_upper=((C)->_upper)+(1);
  905. rT234put(C,a1,(C)->_upper);
  906. }
  907. void rT234put(T234 *C,T0 * a1,int a2){
  908. (C->_storage)[a2-(C->_lower)]=a1;
  909. }
  910. void rT234copy(T234 *C,T0* a1){
  911. int _i=0;
  912. C->_upper=((C)->_lower)-(1);
  913. /*IF*/if (((C)->_capacity)==(0)) {
  914. rT234make(C,((T234*)a1)->_lower,((T234*)a1)->_upper);
  915. }
  916. else {
  917. rT234resize(C,((T234*)a1)->_lower,((T234*)a1)->_upper);
  918. }
  919. /*FI*/_i=(C)->_lower;
  920. while (!((_i)>((C)->_upper))) {
  921. rT234put(C,rT234item((T234*)a1,_i),_i);
  922. _i=(_i)+(1);
  923. }
  924. }
  925. void rT234make(T234 *C,int a1,int a2){
  926. /*IF*/{/*AT*/free(C->_storage);
  927. }
  928. /*FI*/C->_lower=a1;
  929. C->_upper=a2;
  930. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  931. C->_storage=NULL;
  932. /*IF*/if (((C)->_capacity)>(0)) {
  933. C->_capacity=((C)->_capacity)+(16);
  934. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  935. rT234clear_all(C);
  936. }
  937. /*FI*/}
  938. void rT232clear_all(T232 *C){
  939. T0 * _value=NULL;
  940. rT232set_all_with(C,_value);
  941. }
  942. T0 * rT232first(T232 *C){
  943. T0 * R=NULL;
  944. R=rT232item(C,(C)->_lower);
  945. return R;
  946. }
  947. int rT232count(T232 *C){
  948. int R=0;
  949. R=(((C)->_upper)-((C)->_lower))+(1);
  950. return R;
  951. }
  952. void rT232set_all_with(T232 *C,T0 * a1){
  953. int _i=0;
  954. _i=(C)->_upper;
  955. while (!((_i)<((C)->_lower))) {
  956. rT232put(C,a1,_i);
  957. _i=(_i)-(1);
  958. }
  959. }
  960. void rT232resize(T232 *C,int a1,int a2){
  961. int _up=0;
  962. int _i=0;
  963. T0* _other=NULL;
  964. {T232 *n=((T232*)new(232));
  965. rT232make(n,a1,a2);
  966. _other=(T0 *)n;}
  967. _i=rT2max((C)->_lower,((T232*)_other)->_lower);
  968. _up=rT2min((C)->_upper,((T232*)_other)->_upper);
  969. while (!((_i)>(_up))) {
  970. rT232put((T232*)_other,rT232item(C,_i),_i);
  971. _i=(_i)+(1);
  972. }
  973. /*IF*/{/*AT*/free(C->_storage);
  974. }
  975. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  976. }
  977. T0 * rT232item(T232 *C,int a1){
  978. T0 * R=NULL;
  979. R=(C->_storage)[a1-(C->_lower)];
  980. return R;
  981. }
  982. void rT232add_last(T232 *C,T0 * a1){
  983. /*IF*/if (((C)->_capacity)<((rT232count(C))+(1))) {
  984. C->_capacity=((C)->_capacity)+(16);
  985. /*IF*/if (((C)->_capacity)==(16)) {
  986. C->_storage=malloc(16*sizeof(*(C->_storage)));
  987. }
  988. else {
  989. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  990. }
  991. /*FI*/}
  992. /*FI*/C->_upper=((C)->_upper)+(1);
  993. rT232put(C,a1,(C)->_upper);
  994. }
  995. void rT232put(T232 *C,T0 * a1,int a2){
  996. (C->_storage)[a2-(C->_lower)]=a1;
  997. }
  998. void rT232copy(T232 *C,T0* a1){
  999. int _i=0;
  1000. C->_upper=((C)->_lower)-(1);
  1001. /*IF*/if (((C)->_capacity)==(0)) {
  1002. rT232make(C,((T232*)a1)->_lower,((T232*)a1)->_upper);
  1003. }
  1004. else {
  1005. rT232resize(C,((T232*)a1)->_lower,((T232*)a1)->_upper);
  1006. }
  1007. /*FI*/_i=(C)->_lower;
  1008. while (!((_i)>((C)->_upper))) {
  1009. rT232put(C,rT232item((T232*)a1,_i),_i);
  1010. _i=(_i)+(1);
  1011. }
  1012. }
  1013. void rT232make(T232 *C,int a1,int a2){
  1014. /*IF*/{/*AT*/free(C->_storage);
  1015. }
  1016. /*FI*/C->_lower=a1;
  1017. C->_upper=a2;
  1018. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1019. C->_storage=NULL;
  1020. /*IF*/if (((C)->_capacity)>(0)) {
  1021. C->_capacity=((C)->_capacity)+(16);
  1022. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1023. rT232clear_all(C);
  1024. }
  1025. /*FI*/}
  1026. void rT229clear_all(T229 *C){
  1027. T0 * _value=NULL;
  1028. rT229set_all_with(C,_value);
  1029. }
  1030. int rT229count(T229 *C){
  1031. int R=0;
  1032. R=(((C)->_upper)-((C)->_lower))+(1);
  1033. return R;
  1034. }
  1035. void rT229set_all_with(T229 *C,T0 * a1){
  1036. int _i=0;
  1037. _i=(C)->_upper;
  1038. while (!((_i)<((C)->_lower))) {
  1039. rT229put(C,a1,_i);
  1040. _i=(_i)-(1);
  1041. }
  1042. }
  1043. void rT229resize(T229 *C,int a1,int a2){
  1044. int _up=0;
  1045. int _i=0;
  1046. T0* _other=NULL;
  1047. {T229 *n=((T229*)new(229));
  1048. rT229make(n,a1,a2);
  1049. _other=(T0 *)n;}
  1050. _i=rT2max((C)->_lower,((T229*)_other)->_lower);
  1051. _up=rT2min((C)->_upper,((T229*)_other)->_upper);
  1052. while (!((_i)>(_up))) {
  1053. rT229put((T229*)_other,rT229item(C,_i),_i);
  1054. _i=(_i)+(1);
  1055. }
  1056. /*IF*/{/*AT*/free(C->_storage);
  1057. }
  1058. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1059. }
  1060. T0 * rT229item(T229 *C,int a1){
  1061. T0 * R=NULL;
  1062. R=(C->_storage)[a1-(C->_lower)];
  1063. return R;
  1064. }
  1065. void rT229add_last(T229 *C,T0 * a1){
  1066. /*IF*/if (((C)->_capacity)<((rT229count(C))+(1))) {
  1067. C->_capacity=((C)->_capacity)+(16);
  1068. /*IF*/if (((C)->_capacity)==(16)) {
  1069. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1070. }
  1071. else {
  1072. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1073. }
  1074. /*FI*/}
  1075. /*FI*/C->_upper=((C)->_upper)+(1);
  1076. rT229put(C,a1,(C)->_upper);
  1077. }
  1078. void rT229put(T229 *C,T0 * a1,int a2){
  1079. (C->_storage)[a2-(C->_lower)]=a1;
  1080. }
  1081. void rT229copy(T229 *C,T0* a1){
  1082. int _i=0;
  1083. C->_upper=((C)->_lower)-(1);
  1084. /*IF*/if (((C)->_capacity)==(0)) {
  1085. rT229make(C,((T229*)a1)->_lower,((T229*)a1)->_upper);
  1086. }
  1087. else {
  1088. rT229resize(C,((T229*)a1)->_lower,((T229*)a1)->_upper);
  1089. }
  1090. /*FI*/_i=(C)->_lower;
  1091. while (!((_i)>((C)->_upper))) {
  1092. rT229put(C,rT229item((T229*)a1,_i),_i);
  1093. _i=(_i)+(1);
  1094. }
  1095. }
  1096. void rT229make(T229 *C,int a1,int a2){
  1097. /*IF*/{/*AT*/free(C->_storage);
  1098. }
  1099. /*FI*/C->_lower=a1;
  1100. C->_upper=a2;
  1101. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1102. C->_storage=NULL;
  1103. /*IF*/if (((C)->_capacity)>(0)) {
  1104. C->_capacity=((C)->_capacity)+(16);
  1105. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1106. rT229clear_all(C);
  1107. }
  1108. /*FI*/}
  1109. void rT223clear_all(T223 *C){
  1110. T0 * _value=NULL;
  1111. rT223set_all_with(C,_value);
  1112. }
  1113. int rT223count(T223 *C){
  1114. int R=0;
  1115. R=(((C)->_upper)-((C)->_lower))+(1);
  1116. return R;
  1117. }
  1118. void rT223set_all_with(T223 *C,T0 * a1){
  1119. int _i=0;
  1120. _i=(C)->_upper;
  1121. while (!((_i)<((C)->_lower))) {
  1122. rT223put(C,a1,_i);
  1123. _i=(_i)-(1);
  1124. }
  1125. }
  1126. void rT223resize(T223 *C,int a1,int a2){
  1127. int _up=0;
  1128. int _i=0;
  1129. T0* _other=NULL;
  1130. {T223 *n=((T223*)new(223));
  1131. rT223make(n,a1,a2);
  1132. _other=(T0 *)n;}
  1133. _i=rT2max((C)->_lower,((T223*)_other)->_lower);
  1134. _up=rT2min((C)->_upper,((T223*)_other)->_upper);
  1135. while (!((_i)>(_up))) {
  1136. rT223put((T223*)_other,rT223item(C,_i),_i);
  1137. _i=(_i)+(1);
  1138. }
  1139. /*IF*/{/*AT*/free(C->_storage);
  1140. }
  1141. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1142. }
  1143. T0 * rT223item(T223 *C,int a1){
  1144. T0 * R=NULL;
  1145. R=(C->_storage)[a1-(C->_lower)];
  1146. return R;
  1147. }
  1148. void rT223add_last(T223 *C,T0 * a1){
  1149. /*IF*/if (((C)->_capacity)<((rT223count(C))+(1))) {
  1150. C->_capacity=((C)->_capacity)+(16);
  1151. /*IF*/if (((C)->_capacity)==(16)) {
  1152. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1153. }
  1154. else {
  1155. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1156. }
  1157. /*FI*/}
  1158. /*FI*/C->_upper=((C)->_upper)+(1);
  1159. rT223put(C,a1,(C)->_upper);
  1160. }
  1161. void rT223put(T223 *C,T0 * a1,int a2){
  1162. (C->_storage)[a2-(C->_lower)]=a1;
  1163. }
  1164. void rT223copy(T223 *C,T0* a1){
  1165. int _i=0;
  1166. C->_upper=((C)->_lower)-(1);
  1167. /*IF*/if (((C)->_capacity)==(0)) {
  1168. rT223make(C,((T223*)a1)->_lower,((T223*)a1)->_upper);
  1169. }
  1170. else {
  1171. rT223resize(C,((T223*)a1)->_lower,((T223*)a1)->_upper);
  1172. }
  1173. /*FI*/_i=(C)->_lower;
  1174. while (!((_i)>((C)->_upper))) {
  1175. rT223put(C,rT223item((T223*)a1,_i),_i);
  1176. _i=(_i)+(1);
  1177. }
  1178. }
  1179. void rT223make(T223 *C,int a1,int a2){
  1180. /*IF*/{/*AT*/free(C->_storage);
  1181. }
  1182. /*FI*/C->_lower=a1;
  1183. C->_upper=a2;
  1184. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1185. C->_storage=NULL;
  1186. /*IF*/if (((C)->_capacity)>(0)) {
  1187. C->_capacity=((C)->_capacity)+(16);
  1188. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1189. rT223clear_all(C);
  1190. }
  1191. /*FI*/}
  1192. void rT217clear_all(T217 *C){
  1193. T0 * _value=NULL;
  1194. rT217set_all_with(C,_value);
  1195. }
  1196. T0 * rT217first(T217 *C){
  1197. T0 * R=NULL;
  1198. R=rT217item(C,(C)->_lower);
  1199. return R;
  1200. }
  1201. int rT217count(T217 *C){
  1202. int R=0;
  1203. R=(((C)->_upper)-((C)->_lower))+(1);
  1204. return R;
  1205. }
  1206. void rT217set_all_with(T217 *C,T0 * a1){
  1207. int _i=0;
  1208. _i=(C)->_upper;
  1209. while (!((_i)<((C)->_lower))) {
  1210. rT217put(C,a1,_i);
  1211. _i=(_i)-(1);
  1212. }
  1213. }
  1214. void rT217resize(T217 *C,int a1,int a2){
  1215. int _up=0;
  1216. int _i=0;
  1217. T0* _other=NULL;
  1218. {T217 *n=((T217*)new(217));
  1219. rT217make(n,a1,a2);
  1220. _other=(T0 *)n;}
  1221. _i=rT2max((C)->_lower,((T217*)_other)->_lower);
  1222. _up=rT2min((C)->_upper,((T217*)_other)->_upper);
  1223. while (!((_i)>(_up))) {
  1224. rT217put((T217*)_other,rT217item(C,_i),_i);
  1225. _i=(_i)+(1);
  1226. }
  1227. /*IF*/{/*AT*/free(C->_storage);
  1228. }
  1229. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1230. }
  1231. T0 * rT217item(T217 *C,int a1){
  1232. T0 * R=NULL;
  1233. R=(C->_storage)[a1-(C->_lower)];
  1234. return R;
  1235. }
  1236. void rT217add_last(T217 *C,T0 * a1){
  1237. /*IF*/if (((C)->_capacity)<((rT217count(C))+(1))) {
  1238. C->_capacity=((C)->_capacity)+(16);
  1239. /*IF*/if (((C)->_capacity)==(16)) {
  1240. C->_storage=malloc(16*sizeof(*(C->_storage)));
  1241. }
  1242. else {
  1243. C->_storage=realloc(C->_storage,((C->_capacity)*sizeof(*(C->_storage))));
  1244. }
  1245. /*FI*/}
  1246. /*FI*/C->_upper=((C)->_upper)+(1);
  1247. rT217put(C,a1,(C)->_upper);
  1248. }
  1249. void rT217put(T217 *C,T0 * a1,int a2){
  1250. (C->_storage)[a2-(C->_lower)]=a1;
  1251. }
  1252. void rT217copy(T217 *C,T0* a1){
  1253. int _i=0;
  1254. C->_upper=((C)->_lower)-(1);
  1255. /*IF*/if (((C)->_capacity)==(0)) {
  1256. rT217make(C,((T217*)a1)->_lower,((T217*)a1)->_upper);
  1257. }
  1258. else {
  1259. rT217resize(C,((T217*)a1)->_lower,((T217*)a1)->_upper);
  1260. }
  1261. /*FI*/_i=(C)->_lower;
  1262. while (!((_i)>((C)->_upper))) {
  1263. rT217put(C,rT217item((T217*)a1,_i),_i);
  1264. _i=(_i)+(1);
  1265. }
  1266. }
  1267. void rT217make(T217 *C,int a1,int a2){
  1268. /*IF*/{/*AT*/free(C->_storage);
  1269. }
  1270. /*FI*/C->_lower=a1;
  1271. C->_upper=a2;
  1272. C->_capacity=(((C)->_upper)-((C)->_lower))+(1);
  1273. C->_storage=NULL;
  1274. /*IF*/if (((C)->_capacity)>(0)) {
  1275. C->_capacity=((C)->_capacity)+(16);
  1276. C->_storage=malloc((size_t)((C->_capacity)*sizeof(*(C->_storage))));
  1277. rT217clear_all(C);
  1278. }
  1279. /*FI*/}
  1280. void rT96clear_all(T96 *C){
  1281. T0 * _value=NULL;
  1282. rT96set_all_with(C,_value);
  1283. }
  1284. int rT96count(T96 *C){
  1285. int R=0;
  1286. R=(((C)->_upper)-((C)->_lower))+(1);
  1287. return R;
  1288. }
  1289. void rT96set_all_with(T96 *C,T0 * a1){
  1290. int _i=0;
  1291. _i=(C)->_upper;
  1292. while (!((_i)<((C)->_lower))) {
  1293. rT96put(C,a1,_i);
  1294. _i=(_i)-(1);
  1295. }
  1296. }
  1297. void rT96resize(T96 *C,int a1,int a2){
  1298. int _up=0;
  1299. int _i=0;
  1300. T0* _other=NULL;
  1301. {T96 *n=((T96*)new(96));
  1302. rT96make(n,a1,a2);
  1303. _other=(T0 *)n;}
  1304. _i=rT2max((C)->_lower,((T96*)_other)->_lower);
  1305. _up=rT2min((C)->_upper,((T96*)_other)->_upper);
  1306. while (!((_i)>(_up))) {
  1307. rT96put((T96*)_other,rT96item(C,_i),_i);
  1308. _i=(_i)+(1);
  1309. }
  1310. /*IF*/{/*AT*/free(C->_storage);
  1311. }
  1312. /*FI*/memcpy(C,_other,sizeof(*C));free(_other);
  1313. }
  1314. T0 * rT96item(T96 *C,int a1){
  1315. T0 * R=NULL;
  1316. R=(C->_storage)[a1-(C->_lower)];
  1317. return R;
  1318. }
  1319.